<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Document</title>
    <style>
        
    </style>
</head>
<body>
    
</body>
<script>
    var arr = [6, 4, 9, 9, 250, 7, 7, 110, 5];
    console.log(arr);

    // 功能：向数组的最后插入新数据
    // 参数：要插入的数据，1+
    // 返回值：插入数据之后的数组的长度
    // 是否改变原数组：是
    // var res = arr.push("hello", "world", "a", true, null, NaN);
    // console.log(res);

    // 功能：向数组的开头插入新数据
    // 参数：要插入的数据，1+
    // 返回值：插入数据之后的数组的长度
    // 是否改变原数组：是
    //  var res = arr.unshift("hello");
    // console.log(res)

    // 功能：合并(可以解析一层数组)，合并之后的数组，在返回值身上
    // 参数：要插入的数据，1+
    // 返回值：插入数据之后的数组
    // 是否改变原数组：是
    // var res = arr.concat("hello", true, [4,[5,6]]);
    // console.log(res);

    // 功能：删除最后一位
    // 参数：不需要插入参数
    // 返回值：删除的数据
    // 是否改变原数组：是
    // var res = arr.pop();
    // console.log(res)

    // 功能：删除的第一位
    // 参数：不需要插入参数
    // 返回值：删除的数据
    // 是否改变原数组：是
    // var res = arr.shift();
    // console.log(res)

    // 功能：翻转数组
    // 参数：不需要插入参数
    // 返回值：翻转数据之后的数组
    // 是否改变原数组：否
    // var res = arr.reverse();
    // console.log(res)

    // 功能：截取，从第m位截到第n位的前一个，如果n省略，表示截到最后
    // 参数：要删除数组的索引
    // 返回值：插入数据之后的数组的长度
    // 是否改变原数组：是
    // var res = arr.slice(3);
    // var res = arr.slice(3, 7);
    // console.log(res)

    // 功能：将数组的数据按照指定字符连接，并转字符
    // 参数：要插入的数据，1+
    // 返回值：插入字符后的字符串
    // 是否改变原数组：是
    // var res = arr.join();
    // var res = arr.join("-");
    // var res = arr.join("");
    // var res = arr.join(" ");
    // console.log(res);

    // 功能：转字符
    // 参数：要插入的数据，1+
    // 返回值：插入数据之后的数组的长度
    // 是否改变原数组：否
    // var res = arr.toString();
    // console.log(res)
    
    // 功能：排序
    // 默认的排序规则：字符的排序
    // arr.sort()
    // 参数：回调函数
        // 回调函数自身有两个形参
        // 回调函数需要有返回值：两个形参的差
    // arr.sort(function(a, b){
    //     return a-b;
    // })
    // console.log(arr);

    // 功能:删除指定并替换成
    // arr.splice(参数1,参数2,参数3)
    // 参数1：开始删除的位置
    // 参数2：删除的个数，可选，表示删除到末尾
    // 参数3~：要插入到删除位置的数据，可选
    // var res = arr.splice(3);
    // var res = arr.splice(3, 1);
    // var res = arr.splice(3, 1, "hello", "world");
    // var res = arr.splice(3, 0, "hello", "world");
    // console.log(res);


    // indexOf
    // 功能：根据数据查索引
    // 参数：要查询的数据
    // 返回值：查到的索引，查询不到为-1
    // 是否改变原数组：否
    // var arr = [4,7,5,3,4,5,7,4,2,4];
    // console.log(arr);
    // var res = arr.indexOf(4);
    // var res = arr.indexOf(4, 1);
    // var res = arr.indexOf(4, 5);
    // var res = arr.indexOf(6);
    // console.log(res);
    // console.log(arr);

    // forEach
    // 功能：遍历数组
    // 参数：回调函数，回调函数又有三个形参：1表示遍历到的数据，2表示对应的索引，3表示数组自身
    // 返回值：undefined
    // 是否改变原数组：看回调函数内部的操作（根据数组内的数据类型决定）
    // var arr = [4,7,5,3,4,5];
    // var arr = [{age:18},{age:19},{age:17}];
    // console.log(arr)
    // var res = arr.forEach(function(val, idx, self){
    //     // console.log(val, idx, self)
    //     // val = val * 1.3;
    //     // console.log(val)
    //     val.age = 20;
    // })
    // console.log(res)
    // console.log(arr)

    // map
    // 功能：同forEach
    // 参数：同forEach
    // 返回值：是一个新数组，数组内，保存了回调函数每次的返回值
    // 是否改变原数组：同forEach
    // var arr = [4,7,5,3,4,5];
    // console.log(arr)
    // var res = arr.map(function(val, idx, self){
    //     console.log(val, idx, self)
    //     return val * 1.3;
    // })
    // console.log(res)
    // console.log(arr)
    // console.log(arr === res);

    // filter
    // 功能：同forEach
    // 参数：同forEach
    // 返回值：是一个新数组，数组内，保存了当回调函数返回true时遍历到的数据的数据
    // 是否改变原数组：同forEach
    // var arr = [4,7,5,3,4,5];
    // console.log(arr)
    // var res = arr.filter(function(val, idx, self){
    //     // console.log(val, idx, self);
    //     return val > 4;
    // })
    // console.log(res)
    // console.log(arr)
    // console.log(arr === res);

    // some
    // 功能：同forEach + filter，规则：只需要数组中有一个数据符合要求。
    // 参数：同forEach
    // 返回值：布尔值，当回调函数中有一个返回true时，结果为true，同时停止遍历；全部为false，才为false（遍历所有）
    // 是否改变原数组：同forEach
    // var arr = [4,7,5,3,4,5];
    // console.log(arr)
    // var res = arr.some(function(val, idx, self){
    //     console.log(val, idx, self);
    //     return val < 4;
    // });
    // console.log(res)
    // console.log(arr)
    // console.log(arr === res);


    // every
    // 功能：同forEach + filter，规则：需要数组中所有数据都符合要求。
    // 参数：同forEach
    // 返回值：布尔值，当回调函数中有一个返回false时，结果为false，同时停止遍历；全部为true，才为true（遍历所有）
    // 是否改变原数组：同forEach
    // var arr = [4,7,5,3,4,5];
    // console.log(arr)
    // var res = arr.every(function(val, idx, self){
    //     console.log(val, idx, self);
    //     return val % 2 === 0;
    // });
    // console.log(res)
    // console.log(arr)
    // console.log(arr === res);


    // reduce
    // 功能：归并
    // 参数：1回调函数，2初始值，可选
        // 回调函数又有四个参数：
            // 1如果reduce有第二个参数，就是这个值；如果reduce没有第二个参数，是数组的第一个数据；之后每次回调函数执行时，表示前一个回调函数的返回值。
            // 2如果reduce有第二个参数，是数组的第一个数据，如果reduce没有第二个参数，是数组的第二个数据
            // 3每次遍历到的数据对应的索引
            // 4数组自身
    // 返回值：最后一次回调函数的返回值
    // 是否改变原数组：同forEach
    // var arr = [4,7,5,3,4,5];
    // console.log(arr);
    // var res = arr.reduce(function(prev, now, idx, self){
    //     console.log(prev, now, idx, self);
    //     return "hello";
    // });
    // var res = arr.reduce(function(prev, now, idx, self){
    //     console.log(prev, now, idx, self);
    //     return "hello";
    // }, "world");
    // console.log(res)
    // console.log(arr)
    // console.log(arr === res);

    // 利用reduce计算数组内数据的累加和
    // var arr = [4,7,5,3,4,5];
    // var res = arr.reduce(function(prev, now){
    //     return prev + now;
    // });
    // console.log(arr);
    // console.log(res);

    
    
    
    
    
    // reduceRight
    // 反向归并

</script>
</html>